home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 1999 May / SGI IRIX 6.5 Applications 1999 May.iso / dist / extras / netscape_lite.idb / usr / share / src / ns_plugin / npunix.c.z / npunix.c
Encoding:
C/C++ Source or Header  |  1999-03-15  |  7.0 KB  |  304 lines

  1. /* -*- Mode: C; tab-width: 4; -*- */
  2. /******************************************************************************
  3.  * Copyright (c) 1996 Netscape Communications. All rights reserved.
  4.  ******************************************************************************/
  5. /*
  6.  * UnixShell.c
  7.  *
  8.  * Netscape Client Plugin API
  9.  * - Function that need to be implemented by plugin developers
  10.  *
  11.  * This file defines a "Template" plugin that plugin developers can use
  12.  * as the basis for a real plugin.  This shell just provides empty
  13.  * implementations of all functions that the plugin can implement
  14.  * that will be called by Netscape (the NPP_xxx methods defined in 
  15.  * npapi.h). 
  16.  *
  17.  * dp Suresh <dp@netscape.com>
  18.  *
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include "npapi.h"
  23.  
  24. /***********************************************************************
  25.  * Instance state information about the plugin.
  26.  *
  27.  * PLUGIN DEVELOPERS:
  28.  *    Use this struct to hold per-instance information that you'll
  29.  *    need in the various functions in this file.
  30.  ***********************************************************************/
  31.  
  32. typedef struct _PluginInstance
  33. {
  34.     int nothing;
  35. } PluginInstance;
  36.  
  37.  
  38. /***********************************************************************
  39.  *
  40.  * Empty implementations of plugin API functions
  41.  *
  42.  * PLUGIN DEVELOPERS:
  43.  *    You will need to implement these functions as required by your
  44.  *    plugin.
  45.  *
  46.  ***********************************************************************/
  47.  
  48. char*
  49. NPP_GetMIMEDescription(void)
  50. {
  51.     return("mime/type:sample:Template Only");
  52. }
  53.  
  54. NPError
  55. NPP_GetValue(void *future, NPPVariable variable, void *value)
  56. {
  57.     NPError err = NPERR_NO_ERROR;
  58.  
  59.     switch (variable) {
  60.         case NPPVpluginNameString:
  61.             *((char **)value) = "Template plugin";
  62.             break;
  63.         case NPPVpluginDescriptionString:
  64.             *((char **)value) =
  65.                 "This plugins handles nothing. This is only"
  66.                 " a template.";
  67.             break;
  68.         default:
  69.             err = NPERR_GENERIC_ERROR;
  70.     }
  71.     return err;
  72. }
  73.  
  74. NPError
  75. NPP_Initialize(void)
  76. {
  77.     return NPERR_NO_ERROR;
  78. }
  79.  
  80.  
  81. jref
  82. NPP_GetJavaClass()
  83. {
  84.     return NULL;
  85. }
  86.  
  87. void
  88. NPP_Shutdown(void)
  89. {
  90. }
  91.  
  92.  
  93. NPError 
  94. NPP_New(NPMIMEType pluginType,
  95.     NPP instance,
  96.     uint16 mode,
  97.     int16 argc,
  98.     char* argn[],
  99.     char* argv[],
  100.     NPSavedData* saved)
  101. {
  102.         PluginInstance* This;
  103.  
  104.     if (instance == NULL)
  105.         return NPERR_INVALID_INSTANCE_ERROR;
  106.         
  107.     instance->pdata = NPN_MemAlloc(sizeof(PluginInstance));
  108.     
  109.     This = (PluginInstance*) instance->pdata;
  110.  
  111.     if (This != NULL)
  112.         return NPERR_NO_ERROR;
  113.     else
  114.         return NPERR_OUT_OF_MEMORY_ERROR;
  115. }
  116.  
  117.  
  118. NPError 
  119. NPP_Destroy(NPP instance, NPSavedData** save)
  120. {
  121.     PluginInstance* This;
  122.  
  123.     if (instance == NULL)
  124.         return NPERR_INVALID_INSTANCE_ERROR;
  125.  
  126.     This = (PluginInstance*) instance->pdata;
  127.  
  128.     /* PLUGIN DEVELOPERS:
  129.      *    If desired, call NP_MemAlloc to create a
  130.      *    NPSavedDate structure containing any state information
  131.      *    that you want restored if this plugin instance is later
  132.      *    recreated.
  133.      */
  134.  
  135.     if (This != NULL) {
  136.         NPN_MemFree(instance->pdata);
  137.         instance->pdata = NULL;
  138.     }
  139.  
  140.     return NPERR_NO_ERROR;
  141. }
  142.  
  143.  
  144.  
  145. NPError 
  146. NPP_SetWindow(NPP instance, NPWindow* window)
  147. {
  148.     PluginInstance* This;
  149.  
  150.     if (instance == NULL)
  151.         return NPERR_INVALID_INSTANCE_ERROR;
  152.  
  153.     if (window == NULL)
  154.         return NPERR_NO_ERROR;
  155.  
  156.     This = (PluginInstance*) instance->pdata;
  157.  
  158.     /*
  159.      * PLUGIN DEVELOPERS:
  160.      *    Before setting window to point to the
  161.      *    new window, you may wish to compare the new window
  162.      *    info to the previous window (if any) to note window
  163.      *    size changes, etc.
  164.      */
  165.  
  166.     return NPERR_NO_ERROR;
  167. }
  168.  
  169.  
  170. NPError 
  171. NPP_NewStream(NPP instance,
  172.               NPMIMEType type,
  173.               NPStream *stream, 
  174.               NPBool seekable,
  175.               uint16 *stype)
  176. {
  177.     NPByteRange range;
  178.     PluginInstance* This;
  179.  
  180.     if (instance == NULL)
  181.         return NPERR_INVALID_INSTANCE_ERROR;
  182.  
  183.     This = (PluginInstance*) instance->pdata;
  184.  
  185.     return NPERR_NO_ERROR;
  186. }
  187.  
  188.  
  189. /* PLUGIN DEVELOPERS:
  190.  *    These next 2 functions are directly relevant in a plug-in which
  191.  *    handles the data in a streaming manner. If you want zero bytes
  192.  *    because no buffer space is YET available, return 0. As long as
  193.  *    the stream has not been written to the plugin, Navigator will
  194.  *    continue trying to send bytes.  If the plugin doesn't want them,
  195.  *    just return some large number from NPP_WriteReady(), and
  196.  *    ignore them in NPP_Write().  For a NP_ASFILE stream, they are
  197.  *    still called but can safely be ignored using this strategy.
  198.  */
  199.  
  200. int32 STREAMBUFSIZE = 0X0FFFFFFF; /* If we are reading from a file in NPAsFile
  201.                    * mode so we can take any size stream in our
  202.                    * write call (since we ignore it) */
  203.  
  204. int32 
  205. NPP_WriteReady(NPP instance, NPStream *stream)
  206. {
  207.     PluginInstance* This;
  208.     if (instance != NULL)
  209.         This = (PluginInstance*) instance->pdata;
  210.  
  211.     return STREAMBUFSIZE;
  212. }
  213.  
  214.  
  215. int32 
  216. NPP_Write(NPP instance, NPStream *stream, int32 offset, int32 len, void *buffer)
  217. {
  218.     if (instance != NULL)
  219.     {
  220.         PluginInstance* This = (PluginInstance*) instance->pdata;
  221.     }
  222.  
  223.     return len;        /* The number of bytes accepted */
  224. }
  225.  
  226.  
  227. NPError 
  228. NPP_DestroyStream(NPP instance, NPStream *stream, NPError reason)
  229. {
  230.     PluginInstance* This;
  231.  
  232.     if (instance == NULL)
  233.         return NPERR_INVALID_INSTANCE_ERROR;
  234.     This = (PluginInstance*) instance->pdata;
  235.  
  236.     return NPERR_NO_ERROR;
  237. }
  238.  
  239.  
  240. void 
  241. NPP_StreamAsFile(NPP instance, NPStream *stream, const char* fname)
  242. {
  243.     PluginInstance* This;
  244.     if (instance != NULL)
  245.         This = (PluginInstance*) instance->pdata;
  246. }
  247.  
  248.  
  249. void 
  250. NPP_Print(NPP instance, NPPrint* printInfo)
  251. {
  252.     if(printInfo == NULL)
  253.         return;
  254.  
  255.     if (instance != NULL) {
  256.         PluginInstance* This = (PluginInstance*) instance->pdata;
  257.     
  258.         if (printInfo->mode == NP_FULL) {
  259.             /*
  260.              * PLUGIN DEVELOPERS:
  261.              *    If your plugin would like to take over
  262.              *    printing completely when it is in full-screen mode,
  263.              *    set printInfo->pluginPrinted to TRUE and print your
  264.              *    plugin as you see fit.  If your plugin wants Netscape
  265.              *    to handle printing in this case, set
  266.              *    printInfo->pluginPrinted to FALSE (the default) and
  267.              *    do nothing.  If you do want to handle printing
  268.              *    yourself, printOne is true if the print button
  269.              *    (as opposed to the print menu) was clicked.
  270.              *    On the Macintosh, platformPrint is a THPrint; on
  271.              *    Windows, platformPrint is a structure
  272.              *    (defined in npapi.h) containing the printer name, port,
  273.              *    etc.
  274.              */
  275.  
  276.             void* platformPrint =
  277.                 printInfo->print.fullPrint.platformPrint;
  278.             NPBool printOne =
  279.                 printInfo->print.fullPrint.printOne;
  280.             
  281.             /* Do the default*/
  282.             printInfo->print.fullPrint.pluginPrinted = FALSE;
  283.         }
  284.         else {    /* If not fullscreen, we must be embedded */
  285.             /*
  286.              * PLUGIN DEVELOPERS:
  287.              *    If your plugin is embedded, or is full-screen
  288.              *    but you returned false in pluginPrinted above, NPP_Print
  289.              *    will be called with mode == NP_EMBED.  The NPWindow
  290.              *    in the printInfo gives the location and dimensions of
  291.              *    the embedded plugin on the printed page.  On the
  292.              *    Macintosh, platformPrint is the printer port; on
  293.              *    Windows, platformPrint is the handle to the printing
  294.              *    device context.
  295.              */
  296.  
  297.             NPWindow* printWindow =
  298.                 &(printInfo->print.embedPrint.window);
  299.             void* platformPrint =
  300.                 printInfo->print.embedPrint.platformPrint;
  301.         }
  302.     }
  303. }
  304.